/*
 * Copyright (C), 2002-2016, 苏宁易购电子商务有限公司
 * FileName: ModelCommodityInfoServiceImpl.java
 * Author:   13075787
 * Date:     2016年7月1日 上午11:30:12
 * Description: //模块目的、功能描述      
 * History: //修改记录
 * <author>      <time>      <version>    <desc>
 * 修改人姓名             修改时间            版本号                  描述
 */
package com.suning.sawp.service.impl.model;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.annotation.Resource;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.google.gson.reflect.TypeToken;
import com.suning.framework.dal.client.DalClient;
import com.suning.rsc.RscException;
import com.suning.rsc.dto.responsedto.MbfResponse;
import com.suning.rsc.httpservice.annotation.EsbEIHttpWired;
import com.suning.rsf.consumer.ServiceLocator;
import com.suning.rsf.pcss.dto.cluster.RsfClusterItemDto;
import com.suning.rsf.pcss.dto.cluster.RsfClusterResponseDto;
import com.suning.rsf.pcss.dto.cluster.RsfItemClusterRequestDto;
import com.suning.rsf.pcss.dto.item.RsfItemInfoResponseDto;
import com.suning.rsf.pcss.dto.supcommdty.RsfSupplierCmmdtyMessageResponseDTO;
import com.suning.rsf.pcss.dto.supcommdty.RsfSupplierCmmdtyMessageValueDto;
import com.suning.sawp.constants.CacheKeyConstants;
import com.suning.sawp.constants.ConfigConstants;
import com.suning.sawp.constants.LoggerConstants;
import com.suning.sawp.dto.esb.ClusterInfoDTO;
import com.suning.sawp.dto.esb.QueryClusterInfoDTO;
import com.suning.sawp.intf.esb.ClusterInfoReq;
import com.suning.sawp.intf.esb.CmmdtyInfoEsbService;
import com.suning.sawp.intf.model.ModelCommodityBaseInfo;
import com.suning.sawp.intf.model.ModelConstant;
import com.suning.sawp.service.util.RedisCacheUtils;
import com.suning.sawp.service.util.SCMConfigUtil;

/**
 * 样机管理-查询商品相关信息<br>
 * 1、商品基本信息，专门为样机管理使用2、查询指定商品的商品簇信息<br>
 * 设置redis缓存，且有开关控制，是否从Redis缓存,默认走redis缓存
 *
 * @author 13075787
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Service("modelCommodityInfoService")
public class ModelCommodityInfoServiceImpl {

    private static Integer NUM_ZERO = 0;

    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(LoggerConstants.SAWP_SERVICE);

    /**
     * 接口执行成功码
     */
    private static String SUCCESS = "0";

    @Resource
    DalClient dalClient;

    @Resource
    RedisCacheUtils cacheUtils;

    /**
     * 商品中心数据是否缓存Redis开关
     */
    private boolean getCacheFlag() {
        boolean result = false;
        // 不配置scm则为开启状态
        String checkFlag = SCMConfigUtil.getConfig(ConfigConstants.MODEL_COMM_CENTER_CACHE_FLAG,
                String.valueOf(ModelConstant.TASK_VALID_STATUS_ENABLE));
        // 默认开启检查任务有效性的开关
        if (String.valueOf(ModelConstant.TASK_VALID_STATUS_ENABLE).equals(checkFlag)) {
            result = true;
        }
        return result;
    }

    /**
     * 商品RSF接口服务
     */
    com.suning.rsf.pcss.service.ProductService productService = ServiceLocator
            .getService(com.suning.rsf.pcss.service.ProductService.class, null);
    com.suning.rsf.pcss.service.SupplierCmmdtyMessageService supplierCmmdtyMessageService = ServiceLocator
            .getService(com.suning.rsf.pcss.service.SupplierCmmdtyMessageService.class, "supplierCmmdtyMessage");
    com.suning.rsf.pcss.service.ClusterService clusterService = ServiceLocator
            .getService(com.suning.rsf.pcss.service.ClusterService.class, null);

    private CmmdtyInfoEsbService cmmdtyInfoEsbService;

    /**
     * 功能描述: <br>
     * 查询指定商品编码的基本信息
     *
     * @param commCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public ModelCommodityBaseInfo queryCommodityBaseInfo(String commCode) {
        ModelCommodityBaseInfo result = null;
        // 参数不为空
        if (StringUtils.isNotBlank(commCode)) {
            // 缓存key
            String cackeKey = String.format(CacheKeyConstants.MODEL_COMM_BASE_INFO, commCode);
            // 从缓存查询数据
            if (this.getCacheFlag()) {
                result = cacheUtils.get(cackeKey, ModelCommodityBaseInfo.class);
                if (null != result) {
                    // 缓存存在则直接返回
                    return result;
                }
            }
            try {
                // 查询商品详情
                RsfItemInfoResponseDto resp = productService.queryProductBD(commCode);
                if (null != resp && SUCCESS.equals(resp.getErrCode())) {
                    result = new ModelCommodityBaseInfo();
                    // 截取前五位作为品类编码
                    String cateCode = null;
                    if (StringUtils.isNotBlank(resp.getBrandId())
                            && resp.getBrandId().length() > ModelConstant.NUM_FIVE) {
                        cateCode = resp.getBrandId().substring(0, ModelConstant.NUM_FIVE).trim();
                    }
                    result.setCateCode(cateCode);
                    result.setCateName(ModelConstant.getCommCateValue(cateCode));
                    if (StringUtils.isNotBlank(resp.getBrandCode())) {
                        result.setBranch4code(resp.getBrandCode().trim());
                    }
                    if (StringUtils.isNotBlank(resp.getBrandId())) {
                        result.setBranch9code(resp.getBrandId().trim());
                    }
                    if (StringUtils.isNotBlank(resp.getBrandName())) {
                        result.setBranchName(resp.getBrandName().trim());
                    }
                    // 商品编码处理为9位编码
                    result.setCommCode(commCode);
                    if (StringUtils.isNotBlank(resp.getItemName())) {
                        result.setCommName(resp.getItemName());
                    } else {
                        result.setCommName(resp.getItemDisplayName());
                    }
                    // 对商品的品类品牌信息校验，不满足则直接返回空
                    if (StringUtils.isBlank(result.getCateCode()) || StringUtils.isBlank(result.getCateName())
                            || StringUtils.isBlank(result.getBranch4code())
                            || StringUtils.isBlank(result.getBranch9code())
                            || StringUtils.isBlank(result.getBranchName())) {
                        LOGGER.warn("样机管理-商品基本信息返回结果缺失，商品编码为%s", commCode);
                        return null;
                    }
                    // 加入缓存
                    if (this.getCacheFlag()) {
                        cacheUtils.setex(cackeKey, CacheKeyConstants.MODEL_COMM_EXPIRE_TIME, result);
                    }
                }
            } catch (Exception e) {
                LOGGER.error("queryProductBD RSF error,", e);
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 查询指定商品的商品簇商品编码列表
     *
     * @param commCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public List<String> queryCommodityClusterCodes(String commCode) {
        List<String> result = null;
        String clusterId = this.getCommClusterId(commCode);
        // 商品簇id不为空
        if (StringUtils.isNotBlank(clusterId)) {
            // 从缓存查询数据
            // 缓存key
            String cackeKey = String.format(CacheKeyConstants.MODEL_COMM_CODE_CLUSTER_LIST, commCode);
            if (this.getCacheFlag()) {
                result = cacheUtils.get(cackeKey, new TypeToken<List<String>>() {
                }.getType());
                if (CollectionUtils.isNotEmpty(result)) {
                    // 缓存存在则直接返回
                    return result;
                }
            }

            // 907版本，等后面发布完成，else中的内容可以剔除
            if (!"1".equals(SCMConfigUtil.getConfig("model_rsf_queryClusterInfo_close"))) {
                RsfItemClusterRequestDto dto = new RsfItemClusterRequestDto();
                dto.setClusterId(clusterId);
                RsfClusterResponseDto rsfClusterResponse = clusterService.queryClusterInfo(dto);
                if (null != rsfClusterResponse && CollectionUtils.isNotEmpty(rsfClusterResponse.getItemClusterlist())) {
                    // 初始化结果
                    result = new ArrayList<String>();
                    // 商品编码去重
                    Set<String> setCodes = new HashSet<String>();
                    for (RsfClusterItemDto rsfClusterItem : rsfClusterResponse.getItemClusterlist()) {
                        if (null != rsfClusterItem && StringUtils.isNotBlank(rsfClusterItem.getPartNumber())) {
                            // 商品编码处理，9位商品编码
                            String theCommCode = CmmdtyUtils.transform9PartNumber(rsfClusterItem.getPartNumber());
                            if (!setCodes.contains(theCommCode)) {
                                result.add(theCommCode);
                            }
                            setCodes.add(theCommCode);
                        }
                    }
                }
            } else {
                ClusterInfoReq clusterInfoReq = new ClusterInfoReq();
                clusterInfoReq.setClusterId(clusterId);
                MbfResponse mbfResponse = null;
                try {
                    mbfResponse = cmmdtyInfoEsbService.queryClusterInfo(clusterInfoReq);
                } catch (RscException e) {
                    LOGGER.error("queryClusterInfo ESB error,商品编码:" + commCode + "簇id:" + clusterId, e);
                }
                if (null != mbfResponse && null != mbfResponse.getOutput()) {
                    QueryClusterInfoDTO resp = (QueryClusterInfoDTO) mbfResponse.getOutput()
                            .getMbfBody(QueryClusterInfoDTO.class);
                    // 判空，不为空才加入到list列表中
                    if (null != resp && CollectionUtils.isNotEmpty(resp.getItemClusterList())) {
                        // 初始化结果
                        result = new ArrayList<String>();
                        // 商品编码去重
                        Set<String> setCodes = new HashSet<String>();
                        for (ClusterInfoDTO clusterInfoDTO : resp.getItemClusterList()) {
                            if (null != clusterInfoDTO && StringUtils.isNotBlank(clusterInfoDTO.getPartNumber())) {
                                // 商品编码处理，9位商品编码
                                String theCommCode = CmmdtyUtils.transform9PartNumber(clusterInfoDTO.getPartNumber());
                                if (!setCodes.contains(theCommCode)) {
                                    result.add(theCommCode);
                                }
                                setCodes.add(theCommCode);
                            }
                        }
                    }
                }
            }
            // 加入缓存
            if (this.getCacheFlag() && CollectionUtils.isNotEmpty(result)) {
                cacheUtils.setex(cackeKey, CacheKeyConstants.MODEL_COMM_EXPIRE_TIME, result);
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 查询指定商品的商品簇商品信息列表
     *
     * @param commCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public List<ModelCommodityBaseInfo> queryCommodityCluster(String commCode) {
        List<ModelCommodityBaseInfo> result = null;
        // 获取该商品编码的簇商品列表
        List<String> commCodes = this.queryCommodityClusterCodes(commCode);
        if (CollectionUtils.isNotEmpty(commCodes)) {
            result = new ArrayList<ModelCommodityBaseInfo>();
            for (String locCommCode : commCodes) {
                ModelCommodityBaseInfo commInfo = this.queryCommodityBaseInfo(locCommCode);
                // 判断商品信息查询无问题（商品名称不为空）则加入到返回列表中
                if (null != commInfo && StringUtils.isNotBlank(commInfo.getCommName())) {
                    result.add(commInfo);
                }
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 获取该商品编码的商品簇信息
     */
    private String getCommClusterId(String commCode) {
        String result = null;
        if (StringUtils.isNotBlank(commCode)) {
            // 商品编码10个0
            String supplierCode = "0000000000";
            // 02：簇号
            String type = "02";
            // 从缓存查询数据
            // 缓存key
            String cackeKey = String.format(CacheKeyConstants.MODEL_COMM_CLUSTER_ID, commCode);
            if (this.getCacheFlag()) {
                result = cacheUtils.get(cackeKey, String.class);
                if (StringUtils.isNotBlank(result)) {
                    // 缓存存在则直接返回
                    return result;
                }
            }
            try {
                // 请求该接口使用18位商品编码
                String locCommCode = CmmdtyUtils.transform18CmmdtyCode(commCode);
                // 获取商品簇信息
                RsfSupplierCmmdtyMessageResponseDTO rsfDto = supplierCmmdtyMessageService
                        .querySupplierCmmdtyMessage(locCommCode, supplierCode, type);
                if (null != rsfDto && SUCCESS.equals(rsfDto.getErrCode())) {
                    List<RsfSupplierCmmdtyMessageValueDto> list = rsfDto.getValue();
                    // 商品只有一个商品簇id信息，取list中的第一条返回到结果中
                    if (CollectionUtils.isNotEmpty(list) && null != list.get(NUM_ZERO)) {
                        RsfSupplierCmmdtyMessageValueDto msgValue = list.get(NUM_ZERO);
                        result = msgValue.getTextContent();
                        // 加入缓存
                        if (this.getCacheFlag() && StringUtils.isNotBlank(result)) {
                            cacheUtils.setex(cackeKey, CacheKeyConstants.MODEL_COMM_EXPIRE_TIME, result);
                        }
                    }
                }
            } catch (Exception e) {
                LOGGER.error("querySupplierCmmdtyMessage RSF error,", e);
            }
        }
        return result;
    }

    /**
     * @return the cmmdtyInfoEsbService
     */
    public CmmdtyInfoEsbService getCmmdtyInfoEsbService() {
        return cmmdtyInfoEsbService;
    }

    /**
     * @param cmmdtyInfoEsbService the cmmdtyInfoEsbService to set
     */
    @EsbEIHttpWired
    public void setCmmdtyInfoEsbService(CmmdtyInfoEsbService cmmdtyInfoEsbService) {
        this.cmmdtyInfoEsbService = cmmdtyInfoEsbService;
    }

}
